﻿using FileAssistant.ZModel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FileAssistant.ZTool
{
    internal class FileControlTool
    {
        //获取某路径下的所有文件名(路径下文件夹内的文件不考虑，只考虑最外层)
        public List<string> GetFileNamesOfOneDir(string path)
        {
            var result = new List<string>();
            string[] filenames = Directory.GetFiles(path);
            result.AddRange(filenames);
            return result;
        }

        // 最外层执行方法
        // 1、不输入第几个的话，默认全部替换，全部替换直接使用string.replace方法
        // 2、不输入文件类型的话，默认对所有文件进行操作
        // 3、不输入重复次数的话，新替换内容不做复制，否则的话需乘以重复次数后形成替换项
        // 4、第几个和重复次数做类型检查，检查不通过弹窗提醒
        // 5、当第几个为正常数值时间，需要计算被替换项目中被替换内容数量
        //     (1):计算数量的过程中，同时记录对应index
        //     (2):使用找到的index直接进行替换，可以从替换侧两侧截断，然后把新的替换内容放在中间连起来
        //         找到index后也可以直接使用StringBuilder的
        //         remove方法在指定位置删除oldcontent
        //         insert方法在指定位置插入newcontent
        //         貌似还不如最初的方法好
        public void ExecuteChange(CheckResult cr)
        {
            //通过前置条件检查后，执行修改
            

        }

        //替换条件检查
        public CheckResult ConditionCheck(string targetPath, string oldContent, string no, string fileType, string newContent, string repeatCount)
        {
            var result = new CheckResult();
            var sb = new StringBuilder();
            var errorCount = 0;
            sb.Append("检查结果：\n");
            if(targetPath == "")
            {
                sb.Append("未输入文件路径\n");
                errorCount++;
            }
            else if (!Directory.Exists(targetPath))
            {
                sb.Append("文件路径不存在\n");
                errorCount++;
            }
            else
            {
                result.TargetPath = targetPath;
            }

            if(oldContent == "")
            {
                sb.Append("未输入被替换项\n");
                errorCount++;
            }
            else
            {
                result.OldContent = oldContent;
            }

            if(no == "")
            {
                result.No = 0;
            }
            else
            {
                int n;
                bool isNumeric = int.TryParse(no, out n);
                if (!isNumeric)
                {
                    sb.Append("【第几项】输入内容非合法数字\n");
                    errorCount++;
                }
                else
                {
                    if (n <= 0)
                    {
                        sb.Append("【第几项】输入数字应该为正数\n");
                        errorCount++;
                    }
                    else
                    {
                        result.No = n;
                    }
                }
            }

            //fileType直接拿过去
            result.FileType = fileType;

            //newContent直接拿过去
            result.NewContent = newContent;

            //重复次数的处理与no类似，稍有区别
            if (repeatCount == "")
            {
                result.RepeatCount = 1;
            }
            else
            {
                int n;
                bool isNumeric = int.TryParse(repeatCount, out n);
                if (!isNumeric)
                {
                    sb.Append("【重复次数】输入内容非合法数字\n");
                    errorCount++;
                }
                else
                {
                    if (n <= 1)
                    {
                        sb.Append("【重复次数】输入数字应该大于1\n");
                        errorCount++;
                    }
                    else
                    {
                        result.RepeatCount = n;
                    }
                }
            }

            if (errorCount == 0)
            {
                result.Pass = true;
                sb.Append("检查通过     "+DateTime.Now+" \n");
            }
            else
            {
                sb.Append($"检查未通过，共存在{errorCount}项错误,请修改后重试     " + DateTime.Now + " \n");
            }
            result.ResultDescription = sb.ToString();
            return result;
        }

        //实现自定义位置新旧内容替换
        public string CreatNewFileName(string beRepalce,string oldContent, int no,string newContent)
        {
            var result = beRepalce;
            var ti = GetTargetIndexs(beRepalce, oldContent);
            if (no <= ti.Count)
            {
                result = ReplaceInOneIndex(beRepalce, ti.Indexs[no - 1], oldContent, newContent);
            }
            return result;
        } 

        //各种string操作
        //从String中找到所有目标String的下标，并且统计其个数
        //str在str1中出现的下标及次数
        public TargetIndexs GetTargetIndexs(string str1,string str2)
        {
            var result = new TargetIndexs();
            var charArr = str1.ToCharArray();
            var oldCTArr = str2.ToCharArray();
            var oldCount = str2.Length;
            for(int i = 0; i < charArr.Length - oldCount + 1; i++)
            {
                var tempIndex1 = i;
                for(int j = 0; j < oldCount; j++)
                {
                    if (charArr[tempIndex1++] == oldCTArr[j])
                    {
                        if(j==oldCTArr.Length - 1)
                        {
                            result.Indexs.Add(tempIndex1-oldCount);
                            result.Count++;
                        }
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return result;
        }

        //指定位置替换
        public string ReplaceInOneIndex(string source,int index,string oldContent,string newContent)
        {
            var newCount = newContent.Length;
            var index2 = index + oldContent.Length;//截取第二段至末尾的起点
            string left = source.Substring(0,index);
            string right = source.Substring(index2);
            return left+ newContent +right;
        }

    }
}
